Computer architecture for emulating n-dimensional workspaces in a correlithm object processing system

ABSTRACT

A device configured to emulate a node in a correlithm object processing system that includes a node engine. The node engine is configured to receive an input correlithm object and to determine distances between the input correlithm object and source correlithm objects in a node table. A correlithm object is a point in an n-dimensional space represented by a binary string. The distance between the input correlithm object and a source correlithm object is determined based on differences between a binary string representing the input correlithm object and binary strings linked with the source correlithm objects. The node engine is configured to identify a source correlithm object from the node table with the shortest distance, to fetch a target correlithm object from the node table linked with the identified source correlithm object, and to output the identified target correlithm object.

TECHNICAL FIELD

The present disclosure relates generally to computer architectures foremulating a processing system, and more specifically to computerarchitectures for emulating a correlithm object processing system.

BACKGROUND

Conventional computers are highly attuned to using operations thatrequire manipulating ordinal numbers, especially ordinal binaryintegers. The value of an ordinal number corresponds with its positionin a set of sequentially ordered number values. These computers useordinal binary integers to represent, manipulate, and store information.These computers rely on the numerical order of ordinal binary integersrepresenting data to perform various operations such as counting,sorting, indexing, and mathematical calculations. Even when performingoperations that involve other number systems (e.g. floating point),conventional computers still resort to using ordinal binary integers toperform any operations.

Ordinal based number systems only provide information about the sequenceorder of the numbers themselves based on their numeric values. Ordinalnumbers do not provide any information about any other types ofrelationships for the data being represented by the numeric values suchas similarity. For example, when a conventional computer uses ordinalnumbers to represent data samples (e.g. images or audio signals),different data samples are represented by different numeric values. Thedifferent numeric values do not provide any information about howsimilar or dissimilar one data sample is from another. Unless there isan exact match in ordinal number values, conventional systems are unableto tell if a data sample matches or is similar to any other datasamples. As a result, conventional computers are unable to use ordinalnumbers by themselves for comparing different data samples and insteadthese computers rely on complex signal processing techniques.Determining whether a data sample matches or is similar to other datasamples is not a trivial task and poses several technical challenges forconventional computers. These technical challenges result in complexprocesses that consume processing power which reduces the speed andperformance of the system. The ability to compare unknown data samplesto known data samples is crucial for many security applications such asface recognition, voice recognition, and fraud detection.

Thus, it is desirable to provide a solution that allows computingsystems to efficiently determine how similar different data samples areto each other and to perform operations based on their similarity.

SUMMARY

Conventional computers are highly attuned to using operations thatrequire manipulating ordinal numbers, especially ordinal binaryintegers. The value of an ordinal number corresponds with its positionin an set of sequentially ordered number values. These computers useordinal binary integers to represent, manipulate, and store information.These computers rely on the numerical order of ordinal binary integersrepresenting data to perform various operations such as counting,sorting, indexing, and mathematical calculations. Even when performingoperations that involve other number systems (e.g. floating point),conventional computers still resort to using ordinal binary integers toperform any operations.

Ordinal based number systems only provide information about the sequenceorder of the numbers themselves based on their numeric values. Ordinalnumbers do not provide any information about any other types ofrelationships for the data being represented by the numeric values suchas similarity. For example, when a conventional computer uses ordinalnumbers to represent data samples (e.g. images or audio signals),different data samples are represented by different numeric values. Thedifferent numeric values do not provide any information about howsimilar or dissimilar one data sample is from another. Unless there isan exact match in ordinal number values, conventional systems are unableto tell if a data sample matches or is similar to any other datasamples. As a result, conventional computers are unable to use ordinalnumbers by themselves for comparing different data samples and insteadthese computers rely on complex signal processing techniques.Determining whether a data sample matches or is similar to other datasamples is not a trivial task and poses several technical challenges forconventional computers. These technical challenges result in complexprocesses that consume processing power which reduces the speed andperformance of the system. The ability to compare unknown data samplesto known data samples is crucial for many applications such as securityapplication (e.g. face recognition, voice recognition, and frauddetection).

The system described in the present application provides a technicalsolution that enables the system to efficiently determine how similardifferent objects are to each other and to perform operations based ontheir similarity. In contrast to conventional systems, the system usesan unconventional configuration to perform various operations usingcategorical numbers and geometric objects, also referred to ascorrelithm objects, instead of ordinal numbers. Using categoricalnumbers and correlithm objects on a conventional device involveschanging the traditional operation of the computer to supportrepresenting and manipulating concepts as correlithm objects. A deviceor system may be configured to implement or emulate a special purposecomputing device capable of performing operations using correlithmobjects. Implementing or emulating a correlithm object processing systemimproves the operation of a device by enabling the device to performnon-binary comparisons (i.e. match or no match) between different datasamples. This enables the device to quantify a degree of similaritybetween different data samples. This increases the flexibility of thedevice to work with data samples having different data types and/orformats, and also increases the speed and performance of the device whenperforming operations using data samples. These technical advantages andother improvements to the device are described in more detail throughoutthe disclosure.

In one embodiment, the system is configured to use binary integers ascategorical numbers rather than ordinal numbers which enables the systemto determine how similar a data sample is to other data samples.Categorical numbers provide information about similar or dissimilardifferent data samples are from each other. For example, categoricalnumbers can be used in facial recognition applications to representdifferent images of faces and/or features of the faces. The systemprovides a technical advantage by allowing the system to assigncorrelithm objects represented by categorical numbers to different datasamples based on how similar they are to other data samples. As anexample, the system is able to assign correlithm objects to differentimages of people such that the correlithm objects can be directly usedto determine how similar the people in the images are to each other. Inother words, the system is able to use correlithm objects in facialrecognition applications to quickly determine whether a captured imageof a person matches any previously stored images without relying onconventional signal processing techniques.

Correlithm object processing systems use new types of data structurescalled correlithm objects that improve the way a device operates, forexample, by enabling the device to perform non-binary data setcomparisons and to quantify the similarity between different datasamples. Correlithm objects are data structures designed to improve theway a device stores, retrieves, and compares data samples in memory.Correlithm objects also provide a data structure that is independent ofthe data type and format of the data samples they represent. Correlithmobjects allow data samples to be directly compared regardless of theiroriginal data type and/or format.

A correlithm object processing system uses a combination of a sensortable, a node table, and/or an actor table to provide a specific set ofrules that improve computer-related technologies by enabling devices tocompare and to determine the degree of similarity between different datasamples regardless of the data type and/or format of the data samplethey represent. The ability to directly compare data samples havingdifferent data types and/or formatting is a new functionality thatcannot be performed using conventional computing systems and datastructures.

In addition, correlithm object processing system uses a combination of asensor table, a node table, and/or an actor table to provide aparticular manner for transforming data samples between ordinal numberrepresentations and correlithm objects in a correlithm object domain.Transforming data samples between ordinal number representations andcorrelithm objects involves fundamentally changing the data type of datasamples between an ordinal number system and a categorical number systemto achieve the previously described benefits of the correlithm objectprocessing system.

Using correlithm objects allows the system or device to compare datasamples (e.g. images) even when the input data sample does not exactlymatch any known or previously stored input values. For example, an inputdata sample that is an image may have different lighting conditions thanthe previously stored images. The differences in lighting conditions canmake images of the same person appear different from each other. Thedevice uses an unconventional configuration that implements a correlithmobject processing system that uses the distance between the data sampleswhich are represented as correlithm objects and other known data samplesto determine whether the input data sample matches or is similar to theother known data samples. Implementing a correlithm object processingsystem fundamentally changes the device and the traditional dataprocessing paradigm. Implementing the correlithm object processingsystem improves the operation of the device by enabling the device toperform non-binary comparisons of data samples. In other words, thedevice is able to determine how similar the data samples are to eachother even when the data samples are not exact matches. In addition, thedevice is able to quantify how similar data samples are to one another.The ability to determine how similar data samples are to each others isunique and distinct from conventional computers that can only performbinary comparisons to identify exact matches.

The problems associated with comparing data sets and identifying matchesbased on the comparison are problems necessarily rooted in computertechnologies. As described above, conventional systems are limited to abinary comparison that can only determine whether an exact match isfound. Emulating a correlithm object processing system provides atechnical solution that addresses problems associated with comparingdata sets and identifying matches. Using correlithm objects to representdata samples fundamentally changes the operation of a device and how thedevice views data samples. By implementing a correlithm objectprocessing system, the device can determine the distance between thedata samples and other known data samples to determine whether the inputdata sample matches or is similar to the other known data samples. Inaddition, the device is able to determine a degree of similarity thatquantifies how similar different data samples are to one another.

Certain embodiments of the present disclosure may include some, all, ornone of these advantages. These advantages and other features will bemore clearly understood from the following detailed description taken inconjunction with the accompanying drawings and claims.

BRIEF DESCRIPTION OF THE DRAWINGS

For a more complete understanding of this disclosure, reference is nowmade to the following brief description, taken in connection with theaccompanying drawings and detailed description, wherein like referencenumerals represent like parts.

FIG. 1 is a schematic view of an embodiment of a special purposecomputer implementing correlithm objects in an n-dimensional space;

FIG. 2 is a perspective view of an embodiment of a mapping betweencorrelithm objects in different n-dimensional spaces;

FIG. 3 is a schematic view of an embodiment of a correlithm objectprocessing system;

FIG. 4 is a protocol diagram of an embodiment of a correlithm objectprocess flow;

FIG. 5 is a schematic diagram of an embodiment a computer architecturefor emulating a correlithm object processing system;

FIG. 6A is a schematic diagram of an embodiment of a distance measuringprocess for a correlithm object processing system;

FIG. 6B is a schematic diagram of another embodiment of a distancemeasuring process for a correlithm object processing system based onhamming distances;

FIG. 7A is a flowchart of an embodiment of a distance measuring processflow;

FIG. 7B is a flowchart of another embodiment of a distance measuringprocess flow based on hamming distances;

FIG. 8 is a schematic diagram of an embodiment of a process foremulating an image input adapter for a correlithm object processingsystem;

FIG. 9 is a flowchart of an embodiment of an image input adaptingemulation method;

FIG. 10 is a schematic diagram of an embodiment of a process foremulating an image output adapter for a correlithm object processingsystem; and

FIG. 11 is a flowchart of an embodiment of an image output adapteremulation method.

DETAILED DESCRIPTION

FIGS. 1-5 describe various embodiments of how a correlithm objectprocessing system may be implemented or emulated in hardware, such as aspecial purpose computer. FIGS. 6A, 6B, 7A, and 7B describe processesfor determining distances between correlithm objects in a correlithmobject processing system. FIGS. 8 and 9 describe an embodiment of animage input adapter for a correlithm object processing system. FIGS. 10and 11 describe an image output adapter for a correlithm objectprocessing system.

FIG. 1 is a schematic view of an embodiment of a user device 100implementing correlithm objects 104 in an n-dimensional space 102.Examples of user devices 100 include, but are not limited to, desktopcomputers, mobile phones, tablet computers, laptop computers, or otherspecial purpose computer platform. The user device 100 is configured toimplement or emulate a correlithm object processing system that usescategorical numbers to represent data samples as correlithm objects 104in a high-dimensional space 102, for example a high-dimensional binarycube. Additional information about the correlithm object processingsystem is described in FIG. 3. Additional information about configuringthe user device 100 to implement or emulate a correlithm objectprocessing system is described in FIG. 5.

Conventional computers rely on the numerical order of ordinal binaryintegers representing data to perform various operations such ascounting, sorting, indexing, and mathematical calculations. Even whenperforming operations that involve other number systems (e.g. floatingpoint), conventional computers still resort to using ordinal binaryintegers to perform any operations. Ordinal based number systems onlyprovide information about the sequence order of the numbers themselvesbased on their numeric values. Ordinal numbers do not provide anyinformation about any other types of relationships for the data beingrepresented by the numeric values, such as similarity. For example, whena conventional computer uses ordinal numbers to represent data samples(e.g. images or audio signals), different data samples are representedby different numeric values. The different numeric values do not provideany information about how similar or dissimilar one data sample is fromanother. In other words, conventional computers are only able to makebinary comparisons of data samples which only results in determiningwhether the data samples match or do not match. Unless there is an exactmatch in ordinal number values, conventional systems are unable to tellif a data sample matches or is similar to any other data samples. As aresult, conventional computers are unable to use ordinal numbers bythemselves for determining similarity between different data samples,and instead these computers rely on complex signal processingtechniques. Determining whether a data sample matches or is similar toother data samples is not a trivial task and poses several technicalchallenges for conventional computers. These technical challenges resultin complex processes that consume processing power which reduces thespeed and performance of the system.

In contrast to conventional systems, the user device 100 operates as aspecial purpose machine for implementing or emulating a correlithmobject processing system. Implementing or emulating a correlithm objectprocessing system improves the operation of the user device 100 byenabling the user device 100 to perform non-binary comparisons (i.e.match or no match) between different data samples. This enables the userdevice 100 to quantify a degree of similarity between different datasamples. This increases the flexibility of the user device 100 to workwith data samples having different data types and/or formats, and alsoincreases the speed and performance of the user device 100 whenperforming operations using data samples. These improvements and otherbenefits to the user device 100 are described in more detail below andthroughout the disclosure.

For example, the user device 100 employs the correlithm objectprocessing system to allow the user device 100 to compare data sampleseven when the input data sample does not exactly match any known orpreviously stored input values. Implementing a correlithm objectprocessing system fundamentally changes the user device 100 and thetraditional data processing paradigm. Implementing the correlithm objectprocessing system improves the operation of the user device 100 byenabling the user device 100 to perform non-binary comparisons of datasamples. In other words, the user device 100 is able to determine howsimilar the data samples are to each other even when the data samplesare not exact matches. In addition, the user device 100 is able toquantify how similar data samples are to one another. The ability todetermine how similar data samples are to each others is unique anddistinct from conventional computers that can only perform binarycomparisons to identify exact matches.

The user device's 100 ability to perform non-binary comparisons of datasamples also fundamentally changes traditional data searching paradigms.For example, conventional search engines rely on finding exact matchesor exact partial matches of search tokens to identify related datasamples. For instance, conventional text-based search engine are limitedto finding related data samples that have text that exactly matchesother data samples. These search engines only provide a binary resultthat identifies whether or not an exact match was found based on thesearch token. Implementing the correlithm object processing systemimproves the operation of the user device 100 by enabling the userdevice 100 to identify related data samples based on how similar thesearch token is to other data sample. These improvements result inincreased flexibility and faster search time when using a correlithmobject processing system. The ability to identify similarities betweendata samples expands the capabilities of a search engine to include datasamples that may not have an exact match with a search token but arestill related and similar in some aspects. The user device 100 is alsoable to quantify how similar data samples are to each other based oncharacteristics besides exact matches to the search token. Implementingthe correlithm object processing system involves operating the userdevice 100 in an unconventional manner to achieve these technologicalimprovements as well as other benefits described below for the userdevice 100.

Computing devices typically rely on the ability to compare data sets(e.g. data samples) to one another for processing. For example, insecurity or authentication applications a computing device is configuredto compare an input of an unknown person to a data set of known people(or biometric information associated with these people). The problemsassociated with comparing data sets and identifying matches based on thecomparison are problems necessarily rooted in computer technologies. Asdescribed above, conventional systems are limited to a binary comparisonthat can only determine whether an exact match is found. As an example,an input data sample that is an image of a person may have differentlighting conditions than previously stored images. In this example,different lighting conditions can make images of the same person appeardifferent from each other. Conventional computers are unable todistinguish between two images of the same person with differentlighting conditions and two images of two different people withoutcomplicated signal processing. In both of these cases, conventionalcomputers can only determine that the images are different. This isbecause conventional computers rely on manipulating ordinal numbers forprocessing.

In contrast, the user device 100 uses an unconventional configurationthat uses correlithm objects to represent data samples. Using correlithmobjects to represent data samples fundamentally changes the operation ofthe user device 100 and how the device views data samples. Byimplementing a correlithm object processing system, the user device 100can determine the distance between the data samples and other known datasamples to determine whether the input data sample matches or is similarto the other known data samples, as explained in detail below. Unlikethe conventional computers described in the previous example, the userdevice 100 is able to distinguish between two images of the same personwith different lighting conditions and two images of two differentpeople by using correlithm objects 104. Correlithm objects allow theuser device 100 to determine whether there are any similarities betweendata samples, such as between two images that are different from eachother in some respects but similar in other respects. For example, theuser device 100 is able to determine that despite different lightingconditions, the same person is present in both images.

In addition, the user device 100 is able to determine a degree ofsimilarity that quantifies how similar different data samples are to oneanother. Implementing a correlithm object processing system in the userdevice 100 improves the operation of the user device 100 when comparingdata sets and identifying matches by allowing the user device 100 toperform non-binary comparisons between data sets and to quantify thesimilarity between different data samples. In addition, using acorrelithm object processing system results in increased flexibility andfaster search times when comparing data samples or data sets. Thus,implementing a correlithm object processing system in the user device100 provides a technical solution to a problem necessarily rooted incomputer technologies.

The ability to implement a correlithm object processing system providesa technical advantage by allowing the system to identify and comparedata samples regardless of whether an exact match has been previousobserved or stored. In other words, using the correlithm objectprocessing system the user device 100 is able to identify similar datasamples to an input data sample in the absence of an exact match. Thisfunctionality is unique and distinct from conventional computers thatcan only identify data samples with exact matches.

Examples of data samples include, but are not limited to, images, files,text, audio signals, biometric signals, electric signals, or any othersuitable type of data. A correlithm object 104 is a point in then-dimensional space 102, sometimes called an “n-space.” The value ofrepresents the number of dimensions of the space. For example, ann-dimensional space 102 may be a 3-dimensional space, a 50-dimensionalspace, a 100-dimensional space, or any other suitable dimension space.The number of dimensions depends on its ability to support certainstatistical tests, such as the distances between pairs of randomlychosen points in the space approximating a normal distribution. In someembodiments, increasing the number of dimensions in the n-dimensionalspace 102 modifies the statistical properties of the system to provideimproved results. Increasing the number of dimensions increases theprobability that a correlithm object 104 is similar to other adjacentcorrelithm objects 104. In other words, increasing the number ofdimensions increases the correlation between how close a pair ofcorrelithm objects 104 are to each other and how similar the correlithmobjects 104 are to each other.

Correlithm object processing systems use new types of data structurescalled correlithm objects 104 that improve the way a device operates,for example, by enabling the device to perform non-binary data setcomparisons and to quantify the similarity between different datasamples. Correlithm objects 104 are data structures designed to improvethe way a device stores, retrieves, and compares data samples in memory.Unlike conventional data structures, correlithm objects 104 are datastructures where objects can be expressed in a high-dimensional spacesuch that distance 106 between points in the space represent thesimilarity between different objects or data samples. In other words,the distance 106 between a pair of correlithm objects 104 in then-dimensional space 102 indicates how similar the correlithm objects 104are from each other and the data samples they represent. Correlithmobjects 104 that are close to each other are more similar to each otherthan correlithm objects 104 that are further apart from each other. Forexample, in a facial recognition application, correlithm objects 104used to represent images of different types of glasses may be relativelyclose to each other compared to correlithm objects 104 used to representimages of other features such as facial hair. An exact match between twodata samples occurs when their corresponding correlithm objects 104 arethe same or have no distance between them. When two data samples are notexact matches but are similar, the distance between their correlithmobjects 104 can be used to indicate their similarities. In other words,the distance 106 between correlithm objects 104 can be used to identifyboth data samples that exactly match each other as well as data samplesthat do not match but are similar. This feature is unique to acorrelithm processing system and is unlike conventional computers thatare unable to detect when data samples are different but similar in someaspects.

Correlithm objects 104 also provide a data structure that is independentof the data type and format of the data samples they represent.Correlithm objects 104 allow data samples to be directly comparedregardless of their original data type and/or format. In some instances,comparing data samples as correlithm objects 104 is computationally moreefficient and faster than comparing data samples in their originalformat. For example, comparing images using conventional data structuresinvolves significant amounts of image processing which is time consumingand consumes processing resources. Thus, using correlithm objects 104 torepresent data samples provides increased flexibility and improvedperformance compared to using other conventional data structures.

In one embodiment, correlithm objects 104 may be represented usingcategorical binary strings. The number of bits used to represent thecorrelithm object 104 corresponds with the number of dimensions of then-dimensional space 102 where the correlithm object 102 is located. Forexample, each correlithm object 104 may be uniquely identified using a64-bit string in a 64-dimensional space 102. In other examples,correlithm objects 104 can be identified using any other suitable numberof bits in a string. In this configuration, the distance 106 between twocorrelithm objects 104 can be determined based on the differencesbetween the bits of the two correlithm objects 104. In other words, thedistance 106 between two correlithm objects can be determined based onhow many individual bits differ between the correlithm objects 104. Thedistance 106 between two correlithm objects 104 can be computed usinghamming distance or any other suitable technique. An example of aprocess for computing the distance between a pair of correlithm objects104 is described in FIGS. 6A, 6B, 7A, and 7B.

In another embodiment, the distance 106 between two correlithm objects104 can be determined using a Minkowski distance such as the Euclideanor “straight-line” distance between the correlithm objects 104. Forexample, the distance 106 between a pair of correlithm objects 104 maybe determined by calculating the square root of the sum of squares ofthe coordinate difference in each dimension.

The user device 100 is configured to implement or emulate a correlithmobject processing system that comprises one or more sensors 302, nodes304, and/or actors 306 in order to convert data samples between realworld values or representations and to correlithm objects 104 in acorrelithm object domain. Sensors 302 are generally configured toconvert real world data samples to the correlithm object domain. Nodes304 are generally configured to process or perform various operations oncorrelithm objects in the correlithm object domain. Actors 306 aregenerally configured to convert correlithm objects 104 into real worldvalues or representations. Additional information about sensors 302,nodes 304, and actors 306 is described in FIG. 3.

Performing operations using correlithm objects 104 in a correlithmobject domain allows the user device 100 to identify relationshipsbetween data samples that cannot be identified using conventional dataprocessing systems. For example, in the correlithm object domain, theuser device 100 is able to identify not only data samples that exactlymatch an input data sample, but also other data samples that havesimilar characteristics or features as the input data samples.Conventional computers are unable to identify these types ofrelationships readily. Using correlithm objects 104 improves theoperation of the user device 100 by enabling the user device 100 toefficiently process data samples and identify relationships between datasamples without relying on signal processing techniques that require asignificant amount of processing resources. These benefits allow theuser device 100 to operate more efficiently than conventional computersby reducing the amount of processing power and resources that are neededto perform various operations.

FIG. 2 is a schematic view of an embodiment of a mapping betweencorrelithm objects 104 in different n-dimensional spaces 102. Whenimplementing a correlithm object processing system, the user device 100performs operations within the correlithm object domain using correlithmobjects 104 in different n-dimensional spaces 102. As an example, theuser device 100 may convert different types of data samples having realworld values into correlithm objects 104 in different n-dimensionalspaces 102. For instance, the user device 100 may convert data samplesof text into a first set of correlithm objects 104 in a firstn-dimensional space 102 and data samples of audio samples as a secondset of correlithm objects 104 in a second n-dimensional space 102.Conventional systems require data samples to be of the same type and/orformat in order to perform any kind of operation on the data samples. Insome instances, some types of data samples cannot be compared becausethere is no common format available. For example, conventional computersare unable to compare data samples of images and data samples of audiosamples because there is no common format. In contrast, the user device100 implementing a correlithm object processing system is able tocompare and perform operations using correlithm objects 104 in thecorrelithm object domain regardless of the type or format of theoriginal data samples.

In FIG. 2, a first set of correlithm objects 104A are defined within afirst n-dimensional space 102A and a second set of correlithm objects104B are defined within a second n-dimensional space 102B. Then-dimensional spaces may have the same number dimensions or a differentnumber of dimensions. For example, the first n-dimensional space 102Aand the second n-dimensional space 102B may both be three dimensionalspaces. As another example, the first n-dimensional space 102A may be athree dimensional space and the second n-dimensional space 102B may be anine dimensional space. Correlithm objects 104 in the firstn-dimensional space 102A and second n-dimensional space 102B are mappedto each other. In other words, a correlithm object 104A in the firstn-dimensional space 102A may reference or be linked with a particularcorrelithm object 104B in the second n-dimensional space 102B. Thecorrelithm objects 104 may also be linked with and referenced with othercorrelithm objects 104 in other n-dimensional spaces 102.

In one embodiment, a data structure such as table 200 may used to map orlink correlithm objects 194 in different n-dimensional spaces 102. Insome instances, table 200 is referred to as a node table. Table 200 isgenerally configured to identify a first plurality of correlithm objects104 in a first n-dimensional space 102 and a second plurality ofcorrelithm objects 104 in a second n-dimensional space 102. Eachcorrelithm object 104 in the first n-dimensional space 102 is linkedwith a correlithm object 104 is the second n-dimensional space 102. Forexample, table 200 may be configured with a first column 202 that listscorrelithm objects 104A as source correlithm objects and a second column204 that lists corresponding correlithm objects 104B as targetcorrelithm objects. In other examples, table 200 may be configured inany other suitable manner or may be implemented using any other suitabledata structure. In some embodiments, one or more mapping functions maybe used to convert between a correlithm object 104 in a firstn-dimensional space and a correlithm object 104 is a secondn-dimensional space.

FIG. 3 is a schematic view of an embodiment of a correlithm objectprocessing system 300 that is implemented by a user device 100 toperform operations using correlithm objects 104. The system 300generally comprises a sensor 302, a node 304, and an actor 306. Thesystem 300 may be configured with any suitable number and/orconfiguration of sensors 302, nodes 304, and actors 306. An example ofthe system 300 in operation is described in FIG. 4. In one embodiment, asensor 302, a node 304, and an actor 306 may all be implemented on thesame device (e.g. user device 100). In other embodiments, a sensor 302,a node 304, and an actor 306 may each be implemented on differentdevices in signal communication with each other for example over anetwork. In other embodiments, different devices may be configured toimplement any combination of sensors 302, nodes 304, and actors 306.

Sensors 302 serve as interfaces that allow a user device 100 to convertreal world data samples into correlithm objects 104 that can be used inthe correlithm object domain. Sensors 302 enable the user device 100compare and perform operations using correlithm objects 104 regardlessof the data type or format of the original data sample. Sensors 302 areconfigured to receive a real world value 320 representing a data sampleas an input, to determine a correlithm object 104 based on the realworld value 320, and to output the correlithm object 104. For example,the sensor 302 may receive an image 301 of a person and output acorrelithm object 322 to the node 304 or actor 306. In one embodiment,sensors 302 are configured to use sensor tables 308 that link aplurality of real world values with a plurality of correlithm objects104 in an n-dimensional space 102. Real world values are any type ofsignal, value, or representation of data samples. Examples of real worldvalues include, but are not limited to, images, pixel values, text,audio signals, electrical signals, and biometric signals. As an example,a sensor table 308 may be configured with a first column 312 that listsreal world value entries corresponding with different images and asecond column 314 that lists corresponding correlithm objects 104 asinput correlithm objects. In other examples, sensor tables 308 may beconfigured in any other suitable manner or may be implemented using anyother suitable data structure. In some embodiments, one or more mappingfunctions may be used to translate between a real world value 320 and acorrelithm object 104 is a n-dimensional space. Additional informationfor implementing or emulating a sensor 302 in hardware is described inFIG. 5.

Nodes 304 are configured to receive a correlithm object 104 (e.g. aninput correlithm object 104), to determine another correlithm object 104based on the received correlithm object 104, and to output theidentified correlithm object 104 (e.g. an output correlithm object 104).In one embodiment, nodes 304 are configured to use node tables 200 thatlink a plurality of correlithm objects 104 from a first n-dimensionalspace 102 with a plurality of correlithm objects 104 in a secondn-dimensional space 102. A node table 200 may be configured similar tothe table 200 described in FIG. 2. Additional information forimplementing or emulating a node 304 in hardware is described in FIG. 5.

Actors 306 serve as interfaces that allow a user device 100 to convertcorrelithm objects 104 in the correlithm object domain back to realworld values or data samples. Actors 306 enable the user device 100 toconvert from correlithm objects 104 into any suitable type of real worldvalue. Actors 306 are configured to receive a correlithm object 104(e.g. an output correlithm object 104), to determine a real world outputvalue 326 based on the received correlithm object 104, and to output thereal world output value 326. The real world output value 326 may be adifferent data type or representation of the original data sample. As anexample, the real world input value 320 may be an image 301 of a personand the resulting real world output value 326 may be text 327 and/or anaudio signal identifying the person. In one embodiment, actors 306 areconfigured to use actor tables 310 that link a plurality of correlithmobjects 104 in an n-dimensional space 102 with a plurality of real worldvalues. As an example, an actor table 310 may be configured with a firstcolumn 316 that lists correlithm objects 104 as output correlithmobjects and a second column 318 that lists real world values. In otherexamples, actor tables 310 may be configured in any other suitablemanner or may be implemented using any other suitable data structure. Insome embodiments, one or more mapping functions may be employed totranslate between a correlithm object 104 in an n-dimensional space anda real world output value 326. Additional information for implementingor emulating an actor 306 in hardware is described in FIG. 5.

A correlithm object processing system 300 uses a combination of a sensortable 308, a node table 200, and/or an actor table 310 to provide aspecific set of rules that improve computer-related technologies byenabling devices to compare and to determine the degree of similaritybetween different data samples regardless of the data type and/or formatof the data sample they represent. The ability to directly compare datasamples having different data types and/or formatting is a newfunctionality that cannot be performed using conventional computingsystems and data structures. Conventional systems require data samplesto be of the same type and/or format in order to perform any kind ofoperation on the data samples. In some instances, some types of datasamples are incompatible with each other and cannot be compared becausethere is no common format available. For example, conventional computersare unable to compare data samples of images with data samples of audiosamples because there is no common format available. In contrast, adevice implementing a correlithm object processing system uses acombination of a sensor table 308, a node table 200, and/or an actortable 310 to compare and perform operations using correlithm objects 104in the correlithm object domain regardless of the type or format of theoriginal data samples. The correlithm object processing system 300 usesa combination of a sensor table 308, a node table 200, and/or an actortable 310 as a specific set of rules that provides a particular solutionto dealing with different types of data samples and allows devices toperform operations on different types of data samples using correlithmobjects 104 in the correlithm object domain. In some instances,comparing data samples as correlithm objects 104 is computationally moreefficient and faster than comparing data samples in their originalformat. Thus, using correlithm objects 104 to represent data samplesprovides increased flexibility and improved performance compared tousing other conventional data structures. The specific set of rules usedby the correlithm object processing system 300 go beyond simply usingroutine and conventional activities in order to achieve this newfunctionality and performance improvements.

In addition, correlithm object processing system 300 uses a combinationof a sensor table 308, a node table 200, and/or an actor table 310 toprovide a particular manner for transforming data samples betweenordinal number representations and correlithm objects 104 in acorrelithm object domain. For example, the correlithm object processingsystem 300 may be configured to transform a representation of a datasample into a correlithm object 104, to perform various operations usingthe correlithm object 104 in the correlithm object domain, and totransform a resulting correlithm object 104 into another representationof a data sample. Transforming data samples between ordinal numberrepresentations and correlithm objects 104 involves fundamentallychanging the data type of data samples between an ordinal number systemand a categorical number system to achieve the previously describedbenefits of the correlithm object processing system 300.

FIG. 4 is a protocol diagram of an embodiment of a correlithm objectprocess flow 400. A user device 100 implements process flow 400 toemulate a correlithm object processing system 300 to perform operationsusing correlithm object 104 such as facial recognition. The user device100 implements process flow 400 to compare different data samples (e.g.images, voice signals, or text) are to each other and to identify otherobjects based on the comparison. Process flow 400 provides instructionsthat allows user devices 100 to achieve the improved technical benefitsof a correlithm object processing system 300.

Conventional systems are configured to use ordinal numbers foridentifying different data samples. Ordinal based number systems onlyprovide information about the sequence order of numbers based on theirnumeric values, and do not provide any information about any other typesof relationships for the data samples being represented by the numericvalues such as similarity. In contrast, a user device 100 can implementor emulate the correlithm object processing system 300 which provides anunconventional solution that uses categorical numbers and correlithmobjects 104 to represent data samples. For example, the system 300 maybe configured to use binary integers as categorical numbers to generatecorrelithm objects 104 which enables the user device 100 to performoperations directly based on similarities between different datasamples. Categorical numbers provide information about how similardifferent data sample are from each other. Correlithm objects 104generated using categorical numbers can be used directly by the system300 for determining how similar different data samples are from eachother without relying on exact matches, having a common data type orformat, or conventional signal processing techniques.

A non-limiting example is provided to illustrate how the user device 100implements process flow 400 to emulate a correlithm object processingsystem 300 to perform facial recognition on an image to determine theidentity of the person in the image. In other examples, the user device100 may implement process flow 400 to emulate a correlithm objectprocessing system 300 to perform voice recognition, text recognition, orany other operation that compares different objects.

At step 402, a sensor 302 receives an input signal representing a datasample. For example, the sensor 302 receives an image of person's faceas a real world input value 320. The input signal may be in any suitabledata type or format. In one embodiment, the sensor 302 may obtain theinput signal in real-time from a peripheral device (e.g. a camera). Inanother embodiment, the sensor 302 may obtain the input signal from amemory or database.

At step 404, the sensor 302 identifies a real world value entry in asensor table 308 based on the input signal. In one embodiment, thesystem 300 identifies a real world value entry in the sensor table 308that matches the input signal. For example, the real world value entriesmay comprise previously stored images. The sensor 302 may compare thereceived image to the previously stored images to identify a real worldvalue entry that matches the received image. In one embodiment, when thesensor 302 does not find an exact match, the sensor 302 finds a realworld value entry that closest matches the received image.

At step 406, the sensor 302 identifies and fetches an input correlithmobject 104 in the sensor table 308 linked with the real world valueentry. At step 408, the sensor 302 sends the identified input correlithmobject 104 to the node 304. In one embodiment, the identified inputcorrelithm object 104 is represented in the sensor table 308 using acategorical binary integer string. The sensor 302 sends the binarystring representing to the identified input correlithm object 104 to thenode 304.

At step 410, the node 304 receives the input correlithm object 104 anddetermines distances 106 between the input correlithm object 104 andeach source correlithm object 104 in a node table 200. In oneembodiment, the distance 106 between two correlithm objects 104 can bedetermined based on the differences between the bits of the twocorrelithm objects 104. In other words, the distance 106 between twocorrelithm objects can be determined based on how many individual bitsdiffer between a pair of correlithm objects 104. The distance 106between two correlithm objects 104 can be computed using hammingdistance or any other suitable technique. An example of a distancemeasuring process for a pair of correlithm objects 104 is described inFIGS. 7A and 7B. In another embodiment, the distance 106 between twocorrelithm objects 104 can be determined using a Minkowski distance suchas the Euclidean or “straight-line” distance between the correlithmobjects 104. For example, the distance 106 between a pair of correlithmobjects 104 may be determined by calculating the square root of the sumof squares of the coordinate difference in each dimension.

At step 412, the node 304 identifies a source correlithm object 104 fromthe node table 200 with the shortest distance 106. A source correlithmobject 104 with the shortest distance from the input correlithm object104 is a correlithm object 104 either matches or most closely matchesthe received input correlithm object 104.

At step 414, the node 304 identifies and fetches a target correlithmobject 104 in the node table 200 linked with the source correlithmobject 104. At step 416, the node 304 outputs the identified targetcorrelithm object 104 to the actor 306. In this example, the identifiedtarget correlithm object 104 is represented in the node table 200 usinga categorical binary integer string. The node 304 sends the binarystring representing to the identified target correlithm object 104 tothe actor 306.

At step 418, the actor 306 receives the target correlithm object 104 anddetermines distances between the target correlithm object 104 and eachoutput correlithm object 104 in an actor table 310. The actor 306 maycompute the distances between the target correlithm object 104 and eachoutput correlithm object 104 in an actor table 310 using a processsimilar to the process described in step 410.

At step 420, the actor 306 identifies an output correlithm object 104from the actor table 310 with the shortest distance 106. An outputcorrelithm object 104 with the shortest distance from the targetcorrelithm object 104 is a correlithm object 104 either matches or mostclosely matches the received target correlithm object 104.

At step 422, the actor 306 identifies and fetches a real world outputvalue in the actor table 310 linked with the output correlithm object104. The real world output value may be any suitable type of data samplethat corresponds with the original input signal. For example, the realworld output value may be text that indicates the name of the person inthe image or some other identifier associated with the person in theimage. As another example, the real world output value may be an audiosignal or sample of the name of the person in the image. In otherexamples, the real world output value may be any other suitable realworld signal or value that corresponds with the original input signal.The real world output value may be in any suitable data type or format.

At step 424, the actor 306 outputs the identified real world outputvalue. In one embodiment, the actor 306 may output the real world outputvalue in real-time to a peripheral device (e.g. a display or a speaker).In one embodiment, the actor 306 may output the real world output valueto a memory or database. In one embodiment, the real world output valueis sent to another sensor 302. For example, the real world output valuemay be sent to another sensor 302 as an input for another process.

FIG. 5 is a schematic diagram of an embodiment a computer architecture500 for emulating a correlithm object processing system 300 in a userdevice 100. The computer architecture 500 comprises a processor 502, amemory 504, a network interface 506, and an input-output (I/O) interface508. The computer architecture 500 may be configured as shown or in anyother suitable configuration.

The processor 502 comprises one or more processors operably coupled tothe memory 504. The processor 502 is any electronic circuitry including,but not limited to, state machines, one or more central processing unit(CPU) chips, logic units, cores (e.g. a multi-core processor),field-programmable gate array (FPGAs), application specific integratedcircuits (ASICs), graphics processing units (GPUs), or digital signalprocessors (DSPs). The processor 502 may be a programmable logic device,a microcontroller, a microprocessor, or any suitable combination of thepreceding. The processor 502 is communicatively coupled to and in signalcommunication with the memory 204. The one or more processors areconfigured to process data and may be implemented in hardware orsoftware. For example, the processor 502 may be 8-bit, 16-bit, 32-bit,64-bit or of any other suitable architecture. The processor 502 mayinclude an arithmetic logic unit (ALU) for performing arithmetic andlogic operations, processor registers that supply operands to the ALUand store the results of ALU operations, and a control unit that fetchesinstructions from memory and executes them by directing the coordinatedoperations of the ALU, registers and other components.

The one or more processors are configured to implement variousinstructions. For example, the one or more processors are configured toexecute instructions to implement sensor engines 510, node engines 512,and actor engines 514. In an embodiment, the sensor engines 510, thenode engines 512, and the actor engines 514 are implemented using logicunits, FPGAs, ASICs, DSPs, or any other suitable hardware. The sensorengines 510, the node engines 512, and the actor engines 514 are eachconfigured to implement a specific set of rules or process that providesan improved technological result.

In one embodiment, the sensor engine 510 is configured to receive a realworld value 320 as an input, to determine a correlithm object 104 basedon the real world value 320, and to output the correlithm object 104.Examples of the sensor engine 510 in operation are described in FIGS. 4and 8.

In one embodiment, the node engine 512 is configured to receive acorrelithm object 104 (e.g. an input correlithm object 104), todetermine another correlithm object 104 based on the received correlithmobject 104, and to output the identified correlithm object 104 (e.g. anoutput correlithm object 104). The node engine 512 is also configured tocompute distances between pairs of correlithm objects 104. Examples ofthe node engine 512 in operation are described in FIGS. 4, 7A, and 7B.

In one embodiment, the actor engine 514 is configured to receive acorrelithm object 104 (e.g. an output correlithm object 104), todetermine a real world output value 326 based on the received correlithmobject 104, and to output the real world output value 326. Examples ofthe actor engine 514 in operation are described in FIGS. 4 and 11.

The memory 504 comprises one or more non-transitory disks, tape drives,or solid-state drives, and may be used as an over-flow data storagedevice, to store programs when such programs are selected for execution,and to store instructions and data that are read during programexecution. The memory 504 may be volatile or non-volatile and maycomprise read-only memory (ROM), random-access memory (RAM), ternarycontent-addressable memory (TCAM), dynamic random-access memory (DRAM),and static random-access memory (SRAM). The memory 504 is operable tostore sensor instructions 516, node instructions 518, actor instructions520, counting tables 522, sensor tables 308, node tables 200, actortables 310, mask tables 524, and/or any other data or instructions. Thesensor instructions 516, the node instructions 518, and the actorinstructions 520 comprise any suitable set of instructions, logic,rules, or code operable to execute the sensor engine 510, node engine512, and the actor engine 514, respectively.

The sensor tables 308, the node tables 200, and the actor tables 310 maybe configured similar to the sensor tables 308, the node tables 200, andthe actor tables 310 described in FIG. 3, respectively.

Counting tables 522 are configured to link a plurality of binary stringswith a plurality of numeric values. In one embodiment, the numeric valueidentifies the number of bits set to a logical high or logical one in acorresponding binary string. For example, a binary string with eightbits set to a logical one will be linked with a numeric value of eight.As an example, a counting table 522 may be configured with a firstcolumn that lists binary strings as input values and a second columnthat lists numeric values as output values. In other examples, countingtables 522 may be configured in any other suitable manner or may beimplemented using any other suitable data structure. An example of acounting table 522 in operation is described in FIGS. 6A and 7A.

Each mask table 524 is linked with a mask that defines an array ofpixels in an image. In one embodiment, each mask at least partiallyoverlaps with at least one other mask. In this configuration, each maskhas at least one pixel in common with another mask. In otherembodiments, the masks are configured to not overlap with other masks.In this configuration, the masks do not have any pixels in common witheach other. Each mask table 524 identifies a plurality of correlithmobject location indexes that are linked with a portion of an aggregatedcorrelithm object. An aggregated correlithm object is a correlithmobject 104 that is composed of a plurality of correlithm objects 104.For example, an aggregated correlithm object may be formed from five,ten, fifteen, or more correlithm objects 104. An aggregated correlithmobject may be formed from any other suitable number of correlithmobjects 104. As an example, a first correlithm object location index maybe linked with a first correlithm object represented by the first 8-bitsof an aggregated correlithm object, a second correlithm object locationindex is linked with a second correlithm object represented by thesecond 8-bits of the aggregated correlithm object, and so on. Each masktable 524 is further configured to link each of the plurality ofcorrelithm object location indexes with a pixel location in a mask. Forexample, a mask table 524 may link a first portion of an aggregatedcorrelithm object that defines a correlithm object 104 with the firstpixel defined by the mask. An example of a mask table 524 in operationis described in FIGS. 10 and 11.

The network interface 506 is configured to enable wired and/or wirelesscommunications. The network interface 506 is configured to communicatedata with any other device or system. For example, the network interface506 may be configured for communication with a modem, a switch, arouter, a bridge, a server, or a client. The processor 502 is configuredto send and receive data using the network interface 506.

The I/O interface 508 may comprise ports, transmitters, receivers,transceivers, or any other devices for transmitting and/or receivingdata with peripheral devices as would be appreciated by one of ordinaryskill in the art upon viewing this disclosure. For example, the I/Ointerface 508 may be configured to communicate data between theprocessor 502 and peripheral hardware such as a graphical userinterface, a display, a mouse, a keyboard, a key pad, and a touch sensor(e.g. a touch screen).

When implementing a correlithm object processing system 300, userdevices 100 measure the distance between different correlithm objects104 to determine how similar the correlithm objects 104 and the datasamples they represent are to each other. FIGS. 6A, 6B, 7A, and 7Bdescribed examples of distance measuring processes that can beimplemented by a user device 100 to compute the distance between a pairof correlithm objects 104 in the correlithm object domain.

FIGS. 6A and 7A combine to describe a distance measuring process for thecorrelithm object processing system 300. FIG. 6A is a schematic diagramof an embodiment of a distance measuring process for the correlithmobject processing system 300. FIG. 7A is a flowchart of an embodiment ofa distance measuring process flow 700. Process 700 provides instructionsthat allows user devices 100 to achieve the previously describedimproved technical benefits of a correlithm object processing system300. The distance measuring process may be used by a node 304 or anactor 306 to determine the distance between a pair of correlithm objects104. For example, a node 304 may implement process 700 to perform step410 in FIG. 4. As another example, an actor 306 may implement process700 to perform step 418 in FIG. 4. The distance between correlithmobjects 104 is proportional to how similar the correlithm objects 104and the objects they represent are to each other. The shorter thedistance between a pair correlithm objects 104 indicates the moresimilar the correlithm objects 104 and the objects they represent are toeach other.

In FIG. 7A at step 702, a node 304 receives an input binary string. Forexample, referring to FIG. 6A, an exclusive-or (XOR) logic gate 601 isconnected to the node 304. In one embodiment, the XOR 601 or XORfunctionality is integrated with the node 304. In other embodiments, theXOR 601 is a device external to the node 304. The XOR 601 is configuredto receive a pair of correlithm objects 104, for example, as a pair ofcategorical binary integer strings. The output of the XOR 601 is passedto the node 304 as an input binary string 602. The input binary stringmay be any suitable length. For instance, the input binary string may be16-bits, 32- bits, 64-bits, 128-bits, or any other suitable number ofbits.

At step 704, the node 304 masks a portion of the input binary string.Referring to FIG. 6A, the node 304 masks a first portion 604 of theinput binary string 602. When the node 304 masks the first portion 604of the input binary string 602 at least a portion of the input binarystring 602 not masked or modified. For example, the node 304 may mask afirst portion 604 of the input binary string 602 and leaves a secondportion 606 of the input binary string 602 unmasked. In one embodiment,the node 304 may use shift registers to extract the unmasked portion ofthe input binary string 602.

At step 706, the node 304 identifies a binary string in a counting table522 matching an unmasked portion of the input binary string. In otherwords, the node 304 identifies an entry in the counting table 522 thatmatches the unmasked portion of the input binary string. The countingtable 522 is configured similar to the counting table 522 described inFIG. 5. Referring to FIG. 6A, the node 304 identifies an input valueentry 608 in the counting table 522 that matches the unmasked secondportion 606 of the input binary string 602.

At step 708, the node 304 identifies and fetches a numeric value linkedwith the identified binary string in the counting table 522. Referringto FIG. 6A, the node 304 identifies an output value entry 610 in thecounting table 522 that is linked with the identified input value entry608.

At step 710, the node 304 increments a counter by the numeric value. Inone embodiment, the counter or counter functionality may be integratedwith the node 304. In other embodiments, the counter may be an externaldevice connected to the node 304. Referring to FIG. 6A, the numericvalue 612 of the identified output numeric value entry 610 in thecounting table 522 is passed to a counter 616 that increments itscurrent count value 618 by the numeric value 612. For example, when anumeric value 612 of seven is passed to the counter 616, the counter 616will increase its current count value 618 by seven.

At step 712, the node 304 determines whether there are anymore portionsof the input binary string to mask. The node 304 returns to step 704when the node 304 determines there are more portions of the input binarystring to mask. The node 304 proceeds to step 714 when the node 304determines there are no more portions of the input binary string tomask.

Referring to FIG. 6A, after incrementing the counter 616 based on theunmasked second portion 606 of the input binary string 602, the node 304returns to step 704 to process the first portion 604 of the input binarystring 602 that was previously masked. In this example, the node 304unmasks the first portion 604 of the input binary string 602 and masksthe second portion 606 of the input binary string 602. The node 304repeats the process of identifying an entry in the counting table 522that matches the unmasked portion of the input binary string 602 andpassing a corresponding numeric value 614 to the counter 616. Thecounter 616 increments its current count value 618 by the numeric value614. This process may be repeated one or more times for any additionalportions of the input binary string 602.

At step 714, the node 304 outputs the current count value 618 of thecounter 616. The current count value 618 indicates the distance betweenthe pair of correlithm objects 104 that were provided to the XOR 601.The current count value 618 may be used by nodes 304 and/or actor 306 todetermine whether a received correlithm object 104 is similar to any ofthe previously known correlithm objects 104.

FIGS. 6B and 7B combine to describe another distance measuring processfor a correlithm object processing system 300 based on hammingdistances. FIG. 6B is a schematic diagram of another embodiment of adistance measuring process for a correlithm object processing system 300based on hamming distances. FIG. 7B is a flowchart of another embodimentof a distance measuring process flow 750 based on hamming distances.Process 750 provides instructions that allows user devices 100 toachieve the previously described improved technical benefits of acorrelithm object processing system 300. The distance measuring processdescribed in FIG. 6B may be used by a node 304 or an actor 306 todetermine the distance between a pair of correlithm objects 104. Forexample, a node 304 may implement the distance measuring process toperform step 410 in FIG. 4. As another example, an actor 306 mayimplement the distance measuring process to perform step 418 in FIG. 4.

In FIG. 7B at step 752, a node 304 obtains a pair of correlithm objects104. The node 304 obtains the pair of correlithm objects 104 to computethe distance between the correlithm objects 104. As an example, the node304 may receive one correlithm object 104 from a sensor 302, node 304,or actor 306 and one correlithm object 104 from a node table 200.

At step 754, the node 304 performs an XOR operation on the pair ofcorrelithm objects to generate a binary string. Referring to FIG. 6B, anXOR 601 is connected to the node 304. In one embodiment, the XOR 601 orXOR functionality is integrated with the node 304. In other embodiments,the XOR 601 is a device external to the node 304. The XOR 601 isconfigured to receive the pair of correlithm objects 104 as a pair ofcategorical binary integer strings. The XOR 601 is configured to outputa binary string 602. The binary string 602 may be any suitable length.For instance, the binary string 602 may be 16-bits, 32- bits, 64-bits,128-bits, or any other suitable number of bits.

At step 756, the node 304 transfers the binary string to a counter usinga shift register. Referring to FIG. 6B, the output of the XOR 601 ispassed to a shift register 603 as a binary string 602. In oneembodiment, the shift register 603 or binary data shifting functionalityis integrated with the node 304. In other embodiments, the shiftregister 603 is a device external to the node 304. In one embodiment,the shift register 603 is configured transfer the binary string to thecounter 616 one bit at a time.

At step 758, the node 304 determines whether the current input to thecounter is a logical high value. For example, the node 304 determineswhether the input bit 605 that is passed to the counter 616 is a logicalhigh value (e.g. a logical one). The node 304 proceeds to step 760 inresponse to determining the current input to the counter is a logicalhigh value.

The node 304 proceeds to step 762 in response to determining the currentinput to the counter in not a logical high value. In other words, thenode proceeds to step 762 in response to determining the input to thecounter is a logical low value (e.g. a logical zero).

At step 760, the node 304 increments a current count value of thecounter. In other words, the node 304 adds one to the current countvalue of the counter when the input bit 605 that is passed to thecounter 616 is a logical high value. In one embodiment, the counter orcounter functionality may be integrated with the node 304. In otherembodiments, the counter may be an external device connected to the node304.

At step 762, the node 304 determines whether there are any more bits inthe binary string to shift into the counter. The node 304 returns tostep 756 in response to determining there are more bits in the binarystring to shift into the counter. The node 304 proceeds to step 764 inresponse to determining there are no more bits in the binary string toshift into the counter.

At step 764, the node 304 outputs the current count value of thecounter. The current count value 618 indicates the distance between thepair of correlithm objects 104 that were provided to the XOR 601. Thecurrent count value 618 may be used by nodes 304 and/or actor 306 todetermine whether a received correlithm object 104 is similar to any ofthe previously known correlithm objects 104.

When implementing a correlithm object processing system 300, userdevices 100 implement various types of sensors 302 and actors 304 inorder to convert real world data samples into and out of the correlithmobject domain. Examples of sensors 302 and actors 306 that areimplemented by a user device 100 to convert images into correlithmobjects 104 and to convert correlithm objects 104 into other types ofdata sample representations are described in FIGS. 8-11.

FIGS. 8 and 9 combine to describe a process for using a sensor 302 toemulate an image input adapter for the correlithm object processingsystem 300. FIG. 8 is a schematic diagram of an embodiment of a processfor emulating an image input adapter for the correlithm objectprocessing system 300 using a sensor 302. FIG. 9 is a flowchart of anembodiment of an image input adapting emulation method 900. Method 900provides instructions that allows user devices 100 to achieve thepreviously described improved technical benefits of a correlithm objectprocessing system 300. An image input adapter is generally configured toconvert an image to a correlithm object 104. Once an image is convertedto a correlithm object 104, the correlithm object 104 can be used forother processes or applications in the correlithm object domain by anode 304 and/or an actor 306 such as facial recognition.

In FIG. 9 at step 902, a sensor 302 receives an image formed by an arrayof pixels. For example, referring to FIG. 8, the sensor 302 receivesimage 802 which is made up of an array of pixels 804. The image maycomprise any number of pixels 804. The image 802 may be any suitabledata type or format. In one embodiment, the sensor 302 may obtain theimage 802 in real-time from a peripheral device (e.g. a camera). Inanother embodiment, the sensor 302 may obtain the image 802 from amemory or database.

At step 904, the sensor 302 determines the dimensions of the array ofpixels. In other words, the sensor 302 determines the size of the imagein terms of pixels. For example, the sensor 302 may determine the imageis a 10 by 10 array of pixels. The sensor 302 may employ any suitabletechnique for determining the size of the image.

At step 906, the sensor 302 defines a plurality of masks. The masks maybe configured similar to the masks described in FIG. 5. In oneembodiment, each mask at least partially overlaps with at least oneother mask. In this configuration, each mask has at least one pixel incommon with another mask. In other embodiments, the masks are configuredto not overlap with other masks. In this configuration, the masks do nothave any pixels in common with each other.

At step 908, the sensor 302 overlays the plurality of masks with theimage to partition the image into a plurality of sub-arrays of pixels.Referring to FIG. 8, a mask 806 is overlaid with the image 802 to definea sub-array of pixels 807. In one embodiment, the plurality of masks maybe overlaid with the image simultaneously to partition the image into aplurality of sub-arrays of pixels. In another embodiment, the masks maybe overlaid with the image sequentially such that less than all of themasks are overlaid with the image at any given time. For example, thesensor 302 may apply one mask at a time with the image.

At step 910, the sensor 302 determines binary values for each pixel in asub-array of pixels. Referring to FIG. 8, the sub-array of pixels 807defined by the mask 806 is initially populated with different pixelvalues that each describe the color (e.g. red-green-blue (RGB) color) orintensity of a pixel in the sub-array of pixels. The pixel values may bein any number units such as decimal. The sensor 302 converts thesub-array of pixels 807 with pixel values to a sub-array of pixels 808where each pixel value is described as a binary string. In oneembodiment, the sensor 302 converts the pixel values to a correlithmobject 104 represented as a categorical binary string using a sensortable 308. The sensor 302 may use a process similar to the processdescribed in steps 402-406 in FIG. 4 to convert from pixel values tocorrelithm objects 104. In other embodiments, the sensor 302 convertsthe pixel values to binary strings using any other suitable technique.

At step 912, the sensor 302 serialize the correlithm objects 104 for thesub-array of pixels to form an aggregated correlithm object for thesub-array of pixels. Referring to FIG. 8, the sensor 302 serializes thecorrelithm objects 104 of the sub-array of pixels 808 to generate anaggregated correlithm object 810. In other words, the sensor 302sequentially appends the binary values of the correlithm objects 104 foreach pixel in the sub-array of pixels 808 to form the aggregatedcorrelithm object 810.

At step 914, the sensor 302 determines whether to generate an aggregatedcorrelithm object for another sub-array of pixels. The sensor 302returns to step 910 when the sensor 302 determines to generate moreaggregated correlithm objects. The sensor 302 proceeds to step 916 whenthe sensor 302 determines to not generate anymore aggregated correlithmobjects 104. The sensor 302 returns to step 910 for each mask to repeatthe process of converting sub-arrays of pixels with pixel values tosub-arrays of pixels where each pixel value is described as a correlithmobject 104. The sensor 302 also repeats the process of serializingbinary strings of correlithm objects 104 to generate an aggregatedcorrelithm object for a mask. The sensor 302 proceeds to step 916 whenthe sensor 302 has completed converting the image into a plurality ofaggregated correlithm objects.

At step 916, the sensor 302 outputs the aggregated correlithm objects.Each aggregated correlithm object is a categorical binary integerstring. The sensor 302 sends the binary string representing to theaggregated correlithm object to a node 304 and/or an actor 306 forfurther processing. In some embodiments, the sensor 302 outputs theaggregated correlithm object to a memory.

FIGS. 10 and 11 combine to describe a process for using an actor 306 toemulate an image output adapter for the correlithm object processingsystem 300. FIG. 10 is a schematic diagram of an embodiment of a processfor emulating an image output adapter for a correlithm object processingsystem 300 using an actor 306. FIG. 11 is a flowchart of an embodimentof an image output adapter emulation method 1100. Method 1100 providesinstructions that allows user devices 100 to achieve the previouslydescribed improved technical benefits of a correlithm object processingsystem 300. An image output adapter is generally configured to convert acorrelithm object 104 to an image or a representation of an image. Forexample, the actor 306 may generate an image based on the correlithmobject 104. As another example, the actor 306 may generate a voicesample that identifies the image and/or elements in the image. Asanother example, the actor 306 may generate a text description of theimage and/or elements in the image.

In FIG. 11 at step 1102, an actor 306 receives an aggregated correlithmobject corresponding with a mask. For example, referring to FIG. 10, theactor 306 receives an aggregated correlithm object 810 that is composedof a plurality of correlithm objects 104. The actor 306 may receive theaggregated correlithm object 810 from either a sensor 302 or a node 304.

At step 1104, the actor 306 identifies the plurality of correlithmobjects 104 in the aggregated correlithm object. The actor 306 may parseout or identify each of the correlithm objects 104 within the aggregatedcorrelithm object.

At step 1106, the actor 306 populates each pixel location in a mask witha correlithm object 104 from the plurality of correlithm objects 104.Referring to FIG.

10, the actor 306 uses a mask table 524 to identify a sub-array ofpixels that is defined by a corresponding mask 806 in the image 802. Theactor 306 populates each pixel in the sub-array of pixels 808 with oneof the correlithm objects 104 obtained from the aggregated correlithmobject 810.

At step 1108, the actor 306 determines a pixel value for each pixellocation in the mask based on the correlithm object 104 at each pixellocation. Referring to FIG. 10, the actor 306 converts each binarystring or correlithm object 104 at each pixel location into acorresponding pixel value. In one embodiment, the actor 306 convertseach binary string or correlithm object 104 at each pixel location intoa corresponding pixel value using an actor table 310. The actor 306 mayuse a process similar to the process described in steps 418-422 in FIG.4 to convert from correlithm objects 104 to pixels values.

At step 1110, the actor 306 outputs a representation of a portion of theimage based on the mask populated with pixel values at each pixellocation. Referring to FIG. 10, the actor 306 may output the sub-arrayof pixels 807 that is populated with pixel values. For example, theactor 306 may generate a portion of image based on the sub-array ofpixels 807. In one embodiment, the actor 306 may output the sub-array ofpixels 807 in real-time to a peripheral device (e.g. a display). In oneembodiment, the actor 306 may output the sub-array of pixels 807 to amemory or database. In one embodiment, the sub-array of pixels 807 issent to a sensor 302. For example, the sub-array of pixels 807 may besent to a sensor 302 as an input for another process. As anotherexample, the actor 306 may generate a voice sample based on thesub-array of pixels 807 that identifies the image and/or elements in theimage. As another example, the actor 306 may generate a text descriptionof the image and/or elements in the image based on the sub-array ofpixels 807.

At step 1112, the actor 306 determines whether there are anymoreaggregated correlithm objects available to process. The actor 306returns to step 1102 when the actor 306 determines there are moreaggregated correlithm objects available. The actor 306 returns to step1102 for each mask to repeat the process of converting aggregatedcorrelithm objects to sub-arrays of pixels populated with pixel values.Otherwise, the actor 306 terminates method 1100 when there are no moreaggregated correlithm objects available to convert for the image.

While several embodiments have been provided in the present disclosure,it should be understood that the disclosed systems and methods might beembodied in many other specific forms without departing from the spiritor scope of the present disclosure. The present examples are to beconsidered as illustrative and not restrictive, and the intention is notto be limited to the details given herein. For example, the variouselements or components may be combined or integrated in another systemor certain features may be omitted, or not implemented.

In addition, techniques, systems, subsystems, and methods described andillustrated in the various embodiments as discrete or separate may becombined or integrated with other systems, modules, techniques, ormethods without departing from the scope of the present disclosure.Other items shown or discussed as coupled or directly coupled orcommunicating with each other may be indirectly coupled or communicatingthrough some interface, device, or intermediate component whetherelectrically, mechanically, or otherwise. Other examples of changes,substitutions, and alterations are ascertainable by one skilled in theart and could be made without departing from the spirit and scopedisclosed herein.

To aid the Patent Office, and any readers of any patent issued on thisapplication in interpreting the claims appended hereto, applicants notethat they do not intend any of the appended claims to invoke 35 U.S.C. §112(f) as it exists on the date of filing hereof unless the words “meansfor” or “step for” are explicitly used in the particular claim.

1. A device configured to emulate a node in a correlithm objectprocessing system, comprising: a memory operable to store: a node tablethat identifies: a plurality of source correlithm objects, wherein eachsource correlithm object is a point in a first n-dimensional spacerepresented by a binary string; and a plurality of target correlithmobjects, wherein: each target correlithm object is a point in a secondn-dimensional space represented by a binary string, and each targetcorrelithm object is linked with a source correlithm object from amongthe plurality of source correlithm objects; and a node engine operablycoupled to the memory, configured to emulate a node configured to:receive an input correlithm object; determine distances between theinput correlithm object and each of the source correlithm objects in thenode table in response to receiving the input correlithm object, whereinthe distance between the input correlithm object and a source correlithmobject is determined based on differences between a binary stringrepresenting the input correlithm object and binary strings linked witheach of the source correlithm objects; identify a source correlithmobject from the node table with the shortest distance; fetch a targetcorrelithm object from the node table linked with the identified sourcecorrelithm object; and output the identified target correlithm object.2. The device of claim 1, wherein the first n-dimensional space and thesecond n-dimensional space have the same number of dimensions.
 3. Thedevice of claim 1, wherein the first n-dimensional space and the secondn-dimensional space have different numbers of dimensions.
 4. The deviceof claim 1, wherein determining distances between the input correlithmobject and each of the source correlithm objects in the node tablecomprises determining a hamming distance between the input correlithmobject and a source correlithm object.
 5. The device of claim 1, whereindetermining distances between the input correlithm object and each ofthe source correlithm objects in the node table comprises: performing anXOR operation between the input correlithm object and a sourcecorrelithm object to generate a binary string; and counting the numberof logical high values in the binary string.
 6. The device of claim 1,wherein the node engine is configured to output the target correlithmobject to an actor engine configured to convert the target correlithmobject into a real world output value.
 7. The device of claim 1, whereinthe node engine is configured to receive the input correlithm objectfrom a sensor engine configured to convert a real world value into theinput correlithm object.
 8. A method for emulating a node in acorrelithm object processing system, comprising: receiving, by a nodeengine, an input correlithm object; determining, by the node engine,distances between the input correlithm object and each of the sourcecorrelithm objects in the node table in response to receiving the inputcorrelithm object, wherein the distance between the input correlithmobject and a source correlithm object is determined based on differencesbetween a binary string representing the input correlithm object andbinary strings linked with each of the source correlithm objects;identifying, by the node engine, a source correlithm object from a nodetable with the shortest distance, wherein the node table identifies: aplurality of source correlithm objects, wherein each source correlithmobject is a point in a first n-dimensional space represented by a binarystring; and a plurality of target correlithm objects, wherein: eachtarget correlithm object is a point in a second n-dimensional spacerepresented by a binary string, and each target correlithm object islinked with a source correlithm object from among the plurality ofsource correlithm objects; fetching, by the node engine, a targetcorrelithm object from the node table linked with the identified sourcecorrelithm object; and outputting, by the node engine, the identifiedtarget correlithm object.
 9. The method of claim 8, wherein the firstn-dimensional space and the second n-dimensional space have the samenumber of dimensions.
 10. The method of claim 8, wherein the firstn-dimensional space and the second n-dimensional space have differentnumbers of dimensions.
 11. The method of claim 8, wherein determiningdistances between the input correlithm object and each of the sourcecorrelithm objects in the node table comprises determining a hammingdistance between the input correlithm object and a source correlithmobject.
 12. The method of claim 8, wherein determining distances betweenthe input correlithm object and each of the source correlithm objects inthe node table comprises: performing an XOR operation between the inputcorrelithm object and a source correlithm object to generate a binarystring; and counting the number of logical high values in the binarystring.
 13. The method of claim 8, wherein outputting the targetcorrelithm object comprises sending the target correlithm object to anactor engine configured to convert the target correlithm object into areal world output value.
 14. The method of claim 8, wherein receivingthe input correlithm object comprises receiving the input correlithmobject from a sensor engine configured to convert a real world valueinto the input correlithm object.
 15. A computer program productcomprising executable instructions stored in a non-transitory computerreadable medium such that when executed by a processor causes theprocessor to emulate a node in a correlithm object processing systemconfigured to: receive an input correlithm object; determine distancesbetween the input correlithm object and each of the source correlithmobjects in the node table in response to receiving the input correlithmobject, wherein the distance between the input correlithm object and asource correlithm object is determined based on differences between abinary string representing the input correlithm object and binarystrings linked with each of the source correlithm objects; identify asource correlithm object from a node table with the shortest distance,wherein the node table identifies: a plurality of source correlithmobjects, wherein each source correlithm object is a point in a firstn-dimensional space represented by a binary string; and a plurality oftarget correlithm objects, wherein: each target correlithm object is apoint in a second n-dimensional space represented by a binary string,and each target correlithm object is linked with a source correlithmobject from among the plurality of source correlithm objects; fetch atarget correlithm object from the node table linked with the identifiedsource correlithm object; and output the identified target correlithmobject.
 16. The computer program product of claim 15, wherein the firstn-dimensional space and the second n-dimensional space have the samenumber of dimensions.
 17. The computer program product of claim 15,wherein the first n-dimensional space and the second n-dimensional spacehave different numbers of dimensions.
 18. The computer program productof claim 15, wherein determining distances between the input correlithmobject and each of the source correlithm objects in the node tablecomprises determining a hamming distance between the input correlithmobject and a source correlithm object.
 19. The computer program productof claim 15, wherein determining distances between the input correlithmobject and each of the source correlithm objects in the node tablecomprises: performing an XOR operation between the input correlithmobject and a source correlithm object to generate a binary string; andcounting the number of logical high values in the binary string.
 20. Thecomputer program product of claim 15, wherein outputting the targetcorrelithm object comprises sending the target correlithm object to anactor configured to convert the target correlithm object into a realworld output value.